MongoDB——第四天 索引操作

好，今天分享下mongodb中关于索引的基本操作，我们日常做开发都避免不了要对程序进行性能优化，而程序的操作无非就是CURD，通常我们又会花费50%的时间在R上面，因为Read操作对用户来说是非常敏感的，处理不好就会被人唾弃。

从算法上来说有5种经典的查找，具体的可以参见我的算法速成系列，这其中就包括我们今天所说的“索引查找”，如果大家对sqlserver比较了解的话，相信索引查找能给我们带来什么样的性能提升吧。

我们首先插入10w数据，上程序说话：

1
2
3
4
5
6
7
8
9
db.person.drop();//删除person集合
//创建10W条数据
for(var i=0; i< 100000; i++){
    db.user.insert({"name":"hxj"+i, "age" : i});
}
   
> db.user.count();
100000

已经有10W条数据了。

性能分析函数（explain）

好了，数据已经插入成功，既然我们要做分析，肯定要有分析的工具，幸好mongodb中给我们提供了一个关键字叫做“explain”，那么怎么用呢？

还是看程序，注意，这里的name字段没有建立任何索引，这里我就查询一个“name10000”的姓名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
> db.user.find({"name" : "hxj"+10000});
{ "_id" : ObjectId("55935a673cb05382291d31a0"), "name" : "hxj10000", "age" : 10000 }
> db.user.find({"name" : "hxj"+10000}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.user",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "name" : {
                                "$eq" : "hxj10000"
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "name" : {
                                        "$eq" : "hxj10000"
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "YJC-PC",
                "port" : 27017,
                "version" : "3.0.4",
                "gitVersion" : "0481c958daeb2969800511e7475dc66986fa9ed5"
        },
        "ok" : 1
}

其中：

1
"stage" : "COLLSCAN",

stage 是COLLSCAN，说明没有走索引，走索引的话会显示IXSCAN。

基于mongo3.0，和2.x的版本有些地方会不大一样。

旧版的话，会有几个Key可以看下：
cursor: 如果出现的是BasicCursor，就是说这里的查找采用的是“表扫描”，也就是顺序查找，很悲催啊。
nscanned:表示数据库浏览了多少个文档。
n: 最终返回了多少个文档。
millis:总共耗时多少毫秒。

建立索引（ensureIndex）

在10w条这么简单的集合中查找一个文档要114毫秒有一点点让人不能接收（2.x版本），好，那么我们该如何优化呢？mongodb中给我们带来了索引查找，看看能不能让我们的查询一飞冲天…..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
> db.user.ensureIndex({"name":1});
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.user.find({"name" : "hxj"+10000}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.user",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "name" : {
                                "$eq" : "hxj10000"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "name" : 1
                                },
                                "indexName" : "name_1",
                                "isMultiKey" : false,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "name" : [
                                                "[\"hxj10000\", \"hxj10000\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "YJC-PC",
                "port" : 27017,
                "version" : "3.0.4",
                "gitVersion" : "0481c958daeb2969800511e7475dc66986fa9ed5"
        },
        "ok" : 1
}

这里我们使用了ensureIndex在name上建立了索引。
1：表示按照name进行升序，-1：表示按照name进行降序。

这回stage 是FETCH。

如果是2.x版本，会有这些信息：
cursor: 如果是BtreeCursor，这么牛X，mongodb采用B树的结构来存放索引，索引名为后面的“name_1”。
nscanned:表示数据库浏览了多少个文档。
n: 最终返回了多少个文档。
millis:总共耗时多少毫秒。

通过这个例子相信大家对索引也有了感官方面的认识了吧。

唯一索引

和sqlserver一样都可以建立唯一索引，重复的键值自然就不能插入，在mongodb中的使用方法是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
db.user.ensureIndex({"name":1},{"unique":true})
/*删除所有数据，发现删除不了*/
> db.user.remove()
2015-07-01T11:29:38.579+0800 E QUERY    Error: remove needs a query
    at Error (<anonymous>)
    at DBCollection._parseRemove (src/mongo/shell/collection.js:305:32)
    at DBCollection.remove (src/mongo/shell/collection.js:328:23)
    at (shell):1:9 at src/mongo/shell/collection.js:305
    
/*删除所有数据*/
> db.user.remove({})
WriteResult({ "nRemoved" : 100000 })
> db.user.ensureIndex({"name":1}, {"unique": true});
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 2,
        "errmsg" : "exception: Index with name: name_1 already exists with different options",
        "code" : 85,
        "ok" : 0
}
> db.user.count()
0
/*清空集合里数据*/
> db.user.drop()
true
> db.user.ensureIndex({"name":1}, {"unique": true});
{
        "createdCollectionAutomatically" : true,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.user.insert({"name":"yjc", "age": 22});
WriteResult({ "nInserted" : 1 })
> db.user.insert({"name":"yjc", "age": 23});
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 11000,
                "errmsg" : "E11000 duplicate key error index: test.user.$name_1 dup key: { : \"yjc\" }"
        }
})

组合索引

有时候我们的查询不是单条件的，可能是多条件，比如查找出生在‘1989-3-2’名字叫‘jack’的同学，那么我们可以建立“姓名”和”生日“的联合索引来加速查询。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
> db.user.insert({"name" : "hxc", "birthday" : "1989-2-2"});
WriteResult({ "nInserted" : 1 })
> db.user.insert({"name" : "jack", "birthday" : "1989-3-2"});
WriteResult({ "nInserted" : 1 })
> db.user.insert({"name" : "joe", "birthday" : "1989-2-22"});
WriteResult({ "nInserted" : 1 })
> db.user.insert({"name" : "mary", "birthday" : "1989-3-12"});
WriteResult({ "nInserted" : 1 })
> db.user.insert({"name" : "jr", "birthday" : "1989-3-2"});
WriteResult({ "nInserted" : 1 })
> db.user.ensureIndex({"name":1, "birthday":1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "ok" : 1
}
> db.user.ensureIndex({"birthday":1, "name":1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 3,
        "numIndexesAfter" : 4,
        "ok" : 1
}

看到上面，大家或者也知道name跟birthday的不同，建立的索引也不同，升序和降序的顺序不同都会产生不同的索引，那么我们可以用getindexes来查看下person集合中到底生成了那些索引。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
> db.user.getIndexes()
[
        {
                "v" : 1,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.user"
        },
        {
                "v" : 1,
                "unique" : true,
                "key" : {
                        "name" : 1
                },
                "name" : "name_1",
                "ns" : "test.user"
        },
        {
                "v" : 1,
                "key" : {
                        "name" : 1,
                        "birthday" : 1
                },
                "name" : "name_1_birthday_1",
                "ns" : "test.user"
        },
        {
                "v" : 1,
                "key" : {
                        "birthday" : 1,
                        "name" : 1
                },
                "name" : "birthday_1_name_1",
                "ns" : "test.user"
        }
]

此时我们肯定很好奇，到底查询优化器会使用哪个查询作为操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
> db.user.find({"name":"jack", "birthday":"1989-3-2"}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.user",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "birthday" : {
                                                "$eq" : "1989-3-2"
                                        }
                                },
                                {
                                        "name" : {
                                                "$eq" : "jack"
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "KEEP_MUTATIONS",
                        "inputStage" : {
                                "stage" : "FETCH",
                                "filter" : {
                                        "birthday" : {
                                                "$eq" : "1989-3-2"
                                        }
                                },
                                "inputStage" : {
                                        "stage" : "IXSCAN",
                                        "keyPattern" : {
                                                "name" : 1
                                        },
                                        "indexName" : "name_1",
                                        "isMultiKey" : false,
                                        "direction" : "forward",
                                        "indexBounds" : {
                                                "name" : [
                                                        "[\"jack\", \"jack\"]"
                                                ]
                                        }
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "YJC-PC",
                "port" : 27017,
                "version" : "3.0.4",
                "gitVersion" : "0481c958daeb2969800511e7475dc66986fa9ed5"
        },
        "ok" : 1
}

看到结果我们要相信查询优化器，它给我们做出的选择往往是最优的，因为我们做查询时，查询优化器会使用我们建立的这些索引来创建查询方案，如果某一个先执行完则其他查询方案被close掉，这种方案会被mongodb保存起来，当然如果非要用自己指定的查询方案，这也是可以的，在mongodb中给我们提供了hint方法让我们可以暴力执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
> db.user.find({"name":"jack", "birthday":"1989-3-2"}).hint({"birthday":1, "name":1}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.user",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "birthday" : {
                                                "$eq" : "1989-3-2"
                                        }
                                },
                                {
                                        "name" : {
                                                "$eq" : "jack"
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "birthday" : 1,
                                        "name" : 1
                                },
                                "indexName" : "birthday_1_name_1",
                                "isMultiKey" : false,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "birthday" : [
                                                "[\"1989-3-2\", \"1989-3-2\"]"
                                        ],
                                        "name" : [
                                                "[\"jack\", \"jack\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "YJC-PC",
                "port" : 27017,
                "version" : "3.0.4",
                "gitVersion" : "0481c958daeb2969800511e7475dc66986fa9ed5"
        },
        "ok" : 1
}

删除索引

可能随着业务需求的变化，原先建立的索引可能没有存在的必要了，可能有的人想说没必要就没必要呗，但是请记住，索引会降低CUD这三种操作的性能，因为这玩意需要实时维护，所以啥问题都要综合考虑一下，这里就把刚才建立的索引清空掉来演示一下:dropIndex的使用。

dropIndex()删除某个索引
dropIndexes()删除全部索引

先查看索引：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
> db.user.getIndexes()
[
        {
                "v" : 1,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.user"
        },
        {
                "v" : 1,
                "key" : {
                        "name" : 1,
                        "birthday" : 1
                },
                "name" : "name_1_birthday_1",
                "ns" : "test.user"
        },
        {
                "v" : 1,
                "key" : {
                        "name" : 1
                },
                "name" : "name_1",
                "ns" : "test.user"
        },
        {
                "v" : 1,
                "key" : {
                        "name" : 1,
                        "unique" : true
                },
                "name" : "name_1_unique_true",
                "ns" : "test.user"
        }
]

删除普通索引：

1
2
> db.user.dropIndex("name_1");
{ "nIndexesWas" : 4, "ok" : 1 }

删除全部索引：

1
2
3
4
5
6
> db.user.dropIndexes();
{
        "nIndexesWas" : 3,
        "msg" : "non-_id indexes dropped for collection",
        "ok" : 1
}

查看还有什么索引

1
2
3
4
5
6
7
8
9
10
11
> db.user.getIndexes()
[
        {
                "v" : 1,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.user"
        }
]

参考：
8天学通MongoDB——第四天 索引操作 - 一线码农 - 博客园
http://www.cnblogs.com/huangxincheng/archive/2012/02/29/2372699.html

赏

谢谢你请我吃糖果

支付宝
微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一个人至少拥有一个梦想，有一个理由去坚强。心若没有栖息的地方，到哪里都是在流浪。